﻿using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Data.OleDb;
using System.Data;
using System.Globalization;


using System.Threading;
using System.Configuration;
using DXL_Library;






/// <summary>
/// Esta clase contiene metodos tipicamente staticos para realizar tareas comunes del lado Web, y donde
/// se hace referencia o utilizan las entidades de los "Services" que consume la parte web
/// </summary>
public class Util
{
    
    
    private static string[] TEXTO_DIAS_ESP =
        {
            "Domingo",
            "Lunes"    ,                
            "Martes",
            "Miércoles",
            "Jueves",
            "Viernes",
            "Sábado",
        };

    /// <summary>
    /// Obtiene el Nombre del día de la semana de acuerdo al día enviado.
    /// </summary>
    /// <param name="fecha">Fecha a evaluar.</param>
    /// <returns>Nombre del día de la semana.</returns>
    public static string ObtenerDiaSemana(DateTime fecha)
    {
        int diaSemana;
        string nombreDia;

        diaSemana = Convert.ToInt32(fecha.DayOfWeek);
        nombreDia = string.Empty;
        try
        {
            nombreDia = TEXTO_DIAS_ESP[diaSemana];

        }
        catch (Exception exception)
        {
            throw (exception);
        }

        return nombreDia;
    }
    public static string DiaFecha(DateTime fecha)
    {
        string txt;
        txt = ObtenerDiaSemana(fecha);


        txt = string.Format("{0} {1}", txt, fecha.ToString("dd/MM/yyyy"));

        return txt;
    }

    public static bool DataTableVacio(DataTable dt)
    {
        bool vacio;

        vacio = (dt == null) || (dt.Rows == null) || (dt.Rows.Count == 0);

        return vacio;
    }
    public static bool NotacionCientifica(string valTexto, out Double val)
    {
        int pos;
        char letraE;
        bool exito;


        exito = false;
        if (valTexto == null)
        {
            throw new ArgumentException("valTexto no puede ser null");
        }

        letraE = 'E';
        pos = valTexto.IndexOf(letraE);
        val = default(Double);

        if (pos > 0)
        {
            string[] partes;

            partes = valTexto.Split(letraE);

            //cada parte debe ser numerica

            try
            {
                val = Double.Parse(partes[0]);

                Double fact;
                Double parte2;

                parte2 = Double.Parse(partes[1]);

                fact = Math.Pow(10.0, parte2);

                val = val * fact;
                exito = true;
            }
            catch
            {

            }
        }
        return exito;
    }

    public static List<string> RenglonEnListaStrings(string renglon)
    {
        List<string> resp;
        string[] separadores = { "\"" };


        if((renglon != null) && renglon.StartsWith(";"))
        {
            throw new ArgumentException(string.Format("El renglon deberia tener un lista de valores y tiene un renglon de fin de seccion \"{0}\"", renglon));
        }
        //renglon puede ser "Agente Nacional""Valor (USD)""Valor (COP)"..sin las comas
        resp = renglon.Split(separadores, StringSplitOptions.RemoveEmptyEntries).ToList<string>();

        return resp;
    }
    public static string RemoverComillas(string texto)
    {
        string resp;
        int largo;
        int inicio;

        inicio = (ComienzaPorComillas(texto)) ? 1 : 0;

        largo = (texto.EndsWith("\"")) ? texto.Length - 2 : texto.Length;

        resp = texto.Substring(inicio, largo);


        return resp;
    }
    public static bool ComienzaPorComillas(string valorStr)
    {
        bool resp;

        resp = valorStr.Trim().StartsWith("\"");

        return resp;
    }
    public static bool DataTableIguales(DataTable a, DataTable b)
    {
        int numColA, numFilA;
        int numColB, numFilB;
        bool resp;

        //se asume que son diferentes
        resp = false;

        if ((a == null) || (b == null))
        {
            throw new ArgumentException("No se puede comparar datables cuando al menos uno de los dos es NULL");
        }

        try
        {
            int i;
            int j;
            NumRegistros(a, out numColA, out numFilA);
            NumRegistros(b, out numColB, out numFilB);

            if ((numFilA == numFilB) && (numColA == numColB))
            {
                //hasta demostrar lo contrario son iguales...
                resp = true;

                for (j = 0; resp && (j < numFilA); j++)
                {
                    for (i = 0; resp && (i < numColA); i++)
                    {
                        resp = (a.Rows[j][i].ToString() == b.Rows[j][i].ToString());
                    }
                }
                /* DEBUG
                if (!resp)
                {
                    int x = 8;
                }
                 * */
            }
            else
            {

            }
        }
        catch
        {

        }


        return resp;

    }
    public static void NumRegistros(DataTable dt, out int numCols, out int numFils)
    {
        if (dt == null)
        {
            throw new ArgumentException("El parametro dt no puede ser null");
        }

        numCols = (dt.Columns != null) ? dt.Columns.Count : 0;

        numFils = (dt.Rows != null) ? dt.Rows.Count : 0;
    }
    /*PARA PROBAR LA TRANSPOSICION QUE SEA SIMETRICA Y CADA CELDA MANTENGA SU VALOR
                                  DataTable aux;
                                  DataTable prueba;
                                  bool aja ;

                                  aux = hc.Hojas[4].Grillas[0].Datos;

                                  //la doble trasposicion debe mantener los mismos datos y estructura
                                  prueba = Util.TrasponerDatos(Util.TrasponerDatos(aux, out aja), out aja);

                                  aja = Util.DataTableIguales(aux, prueba);
                                  */

    /// <summary>
    /// Esta funcion hace transpocion de las columnas como filas
    /// </summary>
    /// <param name="orig"></param>
    /// <param name="exito"></param>
    /// <returns></returns>
    public static DataTable TrasponerDatos(DataTable orig, out bool exito)
    {
        DataRow dr;
        DataTable traspuestos;

        exito = false;
        traspuestos = null;
        if (orig != null)
        {
            traspuestos = new DataTable();

            int fil;
            int col;

            fil = 0;
            col = 0;


            traspuestos.Columns.Add(orig.Columns[0].ToString());


            //trasponer la PRIMERA COLUMNA y convertirla en los titulos
            for (fil = 0; fil < orig.Rows.Count; fil++)
            {
                traspuestos.Columns.Add(orig.Rows[fil][0].ToString());
            }

            for (col = 1; col < orig.Columns.Count; col++)
            {
                dr = traspuestos.NewRow();

                for (fil = 0; fil <= orig.Rows.Count; fil++)
                {

                    if (fil == 0)
                    {
                        dr[fil] = orig.Columns[col];
                    }
                    else
                    {
                        dr[fil] = orig.Rows[fil - 1][col];
                    }
                }

                traspuestos.Rows.Add(dr);

            }
            exito = (traspuestos.Rows.Count == orig.Columns.Count - 1) && (traspuestos.Columns.Count - 1 == orig.Rows.Count);



        }

        return traspuestos;
    }

   
    public static string PartirRenglon(string renglon, string separador)
    {
        string parte1;
        int mitad;
        string parte2;

        if (renglon == null)
        {
            throw new ArgumentNullException("el parametro renglon debe ser diferente de nulo");
        }
        if (separador == null)
        {
            throw new ArgumentNullException("el parametro separador debe ser diferente de nulo");
        }
        mitad = renglon.Length / 2;

        parte1 = renglon.Substring(0, mitad);
        parte2 = renglon.Substring(mitad);

        //PARTIRLA en el primer espacio cercano a mitad
        if (!parte1.EndsWith(" "))
        {
            int posa;
            int posb;
            int min;

            posa = parte1.Length - parte1.LastIndexOf(' ');
            posb = parte2.IndexOf(' ');

            if (posa < posb)
            {
                min = parte1.LastIndexOf(' ');
            }
            else
            {
                min = parte1.Length + posb;
            }

            parte1 = renglon.Substring(0, min);
            //+1 para no incluir el espacio como tal
            parte2 = renglon.Substring(min + 1);
        }
        renglon = parte1 + separador + parte2;

        return renglon;
    }



   
   
    public static bool EsCadenaVacia(string txt)
    {
        return ((txt == null) || (txt.Trim() == string.Empty));
    }
    public static bool CadenaConTexto(string txt)
    {
        return !EsCadenaVacia(txt);
    }

    public static string SinRuta(string rutaArch)
    {
        int pos;
        string resp;

        resp = string.Empty;

        if (!Util.EsCadenaVacia(rutaArch))
        {
            pos = rutaArch.LastIndexOf('\\') + 1;

            if (pos <= rutaArch.Length)
            {
                resp = rutaArch.Substring(pos);
            }

        }
        return resp;


    }


    public static string DD_MM_AAAA = "dd/MM/yyyy";

    public static bool Obtenerfecha(string strFecha, out DateTime resp, out string msg)
    {
        bool exito;
        string[] formats;

        resp = new DateTime();

        exito = false;

        formats = new string[4];



        formats[0] = "MM/dd/yyyy";
        formats[1] = "M/d/yyyy";
        formats[2] = "dd/MM/yyyy";
        formats[3] = "d/M/yyyy";

        msg = string.Empty;

        try
        {
            //strFecha = "03/12/2011 12:00:00 a.m." ahora !!
            if (!DateTime.TryParse(strFecha, out resp))
            {
                resp = DateTime.ParseExact(strFecha, formats, null, System.Globalization.DateTimeStyles.None);

                //BUG 0022224
                //Se observa en cada una de las pestañas cargadas de Liquidación el formato de fecha MM/DD/AAAA diferente al archivo fuente, 
                //en este se presenta el formato de fecha: DD/MM/AAAA.
                string aux;

                aux = resp.ToString(DD_MM_AAAA);
                resp = DateTime.Parse(aux);
                exito = true;
            }
            else
            {
                exito = true;
            }
        }
        catch (Exception ex)
        {
            msg = string.Format("Error al interpretar fecha {0}:{1} ", strFecha, ex.Message);
        }

        return exito;
    }
    

    private static string prefijoComun = string.Empty;

    private static void EstablecerFrefijoComun(string val)
    {
        if ((val != null) && (val != string.Empty))
        {
            prefijoComun = val;
        }
        else
        {
            prefijoComun = string.Empty;
        }
    }
    private static string PrefijoSegunColumna(List<string> prefijosColumnas, int numCol)
    {
        string resp;

        resp = string.Empty;
        if (prefijoComun != string.Empty)
        {
            resp = prefijoComun;
        }

        if ((prefijosColumnas != null) && (numCol >= 0) && (numCol < prefijosColumnas.Count))
        {
            resp = prefijosColumnas[numCol];
        }

        return resp;
    }
    private static Random rand;

    public static int ObtenerValorAleatorio(int min, int max)
    {
        int resp;

        if (rand == null)
        {
            rand = new Random(DateTime.Now.Millisecond);
        }

        resp = rand.Next(min, max);

        return resp;
    }
    public static bool DatosRandom(DataTable dt, string prefijo, int numFil)
    {
        EstablecerFrefijoComun(prefijo);

        return DatosRandom(dt, (List<string>)null, numFil);
    }

    public static bool DatosRandom(DataTable dt, List<string> prefijoColumnas, int numFil)
    {
        int i;
        int j;
        DataRow dr;
        int numCol;
        bool exito;


        exito = false;

        if ((dt == null) || (dt.Columns == null))
        {
            throw new ArgumentException("No se puede generar datos aleatorias para un grilla que no tiene definidas columnas");
        }

        numCol = dt.Columns.Count;


        for (j = 0; j < numFil; j++)
        {
            dr = dt.NewRow();

            for (i = 0; i < numCol; i++)
            {
                dr[i] = string.Format("{0}{1}", PrefijoSegunColumna(prefijoColumnas, numCol), ObtenerValorAleatorio(0, 1000));
            }


            dt.Rows.Add(dr);
        }

        exito = true;

        return exito;
    }

    public static bool INTERPRETAR_VACIO_COMO_CERO = true;

    
}





